package com.yundingai.service.impl;
import io.minio.GetObjectArgs;
import io.minio.MinioClient;
import io.minio.errors.MinioException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.codec.ServerSentEvent;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;

import java.io.IOException;
import java.io.InputStream;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
/**
 * @Author HuangZhengmin
 * @desc
 * @Date 2025/7/17 12:24
 * @Version 1.0
 */
@Slf4j
@Service
public class MinioService {
  @Autowired
  private MinioClient minioClient;

  @Value("${minio.bucketName}")
  private String bucketName;

  @Autowired
  private FileAnalysisService fileAnalysisService;

  /**
   * 基于MinIOUtil新增：分析Minio中的文件内容
   * @param objectName Minio中的对象名称
   * @return AI分析结果
   */
  public String analyzeFile(String objectName) {
    try {
      // 1. 从Minio获取文件字节数据
      byte[] fileData = getFileBytes(objectName);

      // 2. 调用分析服务
      return fileAnalysisService.analyzeFileContent(fileData);

    } catch (Exception e) {
      throw new RuntimeException("文件分析失败: " + objectName, e);
    }
  }

  /**
   * 从Minio获取文件字节数据
   */
  private byte[] getFileBytes(String objectName) throws MinioException, InvalidKeyException,
          NoSuchAlgorithmException, IOException {
    try (InputStream stream = minioClient.getObject(
            GetObjectArgs.builder()
                    .bucket(bucketName)
                    .object(objectName)
                    .build())) {
      return stream.readAllBytes();
    }
  }

  /**
   * 流式分析Minio中的文件
   * @param objectName Minio中的对象名称
   * @return ServerSentEvent流
   */
  public Flux<ServerSentEvent<String>> streamAnalyzeFile(String objectName) {
    return Flux.using(
            () -> minioClient.getObject(
                    GetObjectArgs.builder()
                            .bucket(bucketName)
                            .object(objectName)
                            .build()),
            inputStream -> {
              try {
                byte[] fileData = inputStream.readAllBytes();
                return fileAnalysisService.streamAnalyzeFile(fileData);
              } catch (IOException e) {
                return Flux.error(e);
              }
            },
            inputStream -> {
              try {
                inputStream.close();
              } catch (IOException e) {
                log.error("关闭输入流失败", e);
              }
            }
    );
  }
  /**
   * 流式处理文件（根据用户需求）
   */
  public Flux<ServerSentEvent<String>> streamProcessFile(String objectName, String userRequest) {
    // 记录开始处理用户需求
    log.info("开始处理用户需求: {}", userRequest);

    // 使用minioClient获取文件
    return Flux.using(
            // 获取文件流
            () -> minioClient.getObject(
                    GetObjectArgs.builder()
                            .bucket(bucketName)
                            .object(objectName)
                            .build()),
            // 处理文件流
            inputStream -> {
              try {
                // 读取文件内容
                byte[] fileData = inputStream.readAllBytes();
                // 调用文件分析服务处理文件内容
                return fileAnalysisService.processFileContent(fileData, userRequest);
              } catch (IOException e) {
                // 记录读取文件失败
                log.error("读取文件失败", e);
                // 返回错误流
                return Flux.error(e);
              }
            },
            // 关闭文件流
            inputStream -> {
              try {
                inputStream.close();
              } catch (IOException e) {
                // 记录关闭文件流失败
                log.error("关闭文件流失败", e);
              }
            }
    );
  }

}